import 'dart:async';
import 'dart:convert'; // 🔥 新增：用于解析消息extra中的JSON数据
import 'dart:developer' as developer;
import 'package:get/get.dart';
import 'package:rongcloud_im_wrapper_plugin/rongcloud_im_wrapper_plugin.dart';
import 'storage_service.dart';
import 'message_storage_service.dart';
import 'user_service.dart';
import '../models/chat_message_entity.dart';
import '../utils/loading_util.dart';
import '../utils/smart_notification_util.dart';
import '../utils/background_notification_helper.dart';
import '../utils/app_lifecycle_manager.dart';

/// 融云IM服务（增强版）
///
/// 🎯 核心职责：
/// - 融云SDK初始化和配置
/// - 连接管理（连接、断开、重连）
/// - 消息接收、发送和存储
/// - 消息类型识别（chat, friend_request, activity_request）
/// - 未读数管理
/// - Token管理
///
/// 📱 支持三种消息类型：
/// 1. chat - 普通好友聊天消息
/// 2. friend_request - 好友申请消息（固定标识）
/// 3. activity_request - 活动申请消息（包含***标识）
///
/// 💡 重要说明：
/// - 融云SDK通过Token自动识别用户身份，无需单独设置用户信息
/// - 发送消息时，融云会自动携带发送者信息
/// - 接收方通过好友列表匹配发送者的详细信息（头像、昵称等）
class RongCloudService extends GetxService {
  static RongCloudService get to => Get.find<RongCloudService>();

  // ==================== 融云配置 ====================

  /// 融云生产环境 App Key
  static const String appKey = 'x4vkb1qpx8r4k';

  /// 融云生产环境 App Secret（仅服务端使用，客户端不应使用）
  static const String appSecret = 'UCbIqxWy9XMo';

  // ==================== 消息类型标识 ====================

  /// 🔥 好友申请消息标识（支持多种格式）
  static const List<String> _friendRequestFlags = ['申请添加你为好友', '好友申请', '添加好友'];

  /// 活动申请消息标识
  static const String _activityRequestFlag = '***';

  // ==================== 本地存储键 ====================

  static const String _keyRongCloudToken = 'rongcloud_token';
  static const String _keyUserId = 'rongcloud_user_id';

  // ==================== 响应式状态 ====================

  /// 融云引擎实例
  RCIMIWEngine? _engine;

  /// 连接状态
  final RxBool isConnected = false.obs;

  /// 连接中状态
  final RxBool isConnecting = false.obs;

  /// 当前连接的用户ID
  final RxString currentUserId = ''.obs;

  /// 当前Token
  final RxString currentToken = ''.obs;

  /// 连接状态枚举
  final Rx<RCIMIWConnectionStatus?> connectionStatus =
      Rx<RCIMIWConnectionStatus?>(null);

  // ==================== 消息流控制器 ====================

  /// 消息流控制器（用于广播新消息）
  final _messageStreamController = StreamController<RCIMIWMessage>.broadcast();

  /// 消息流（供外部监听）
  Stream<RCIMIWMessage> get messageStream => _messageStreamController.stream;

  // ==================== 回调管理 ====================

  /// 消息接收回调
  Function(RCIMIWMessage message)? onMessageReceived;

  /// 连接状态变化回调
  Function(RCIMIWConnectionStatus status)? onConnectionStatusChanged;

  /// 连接成功回调
  Function()? onConnectedSuccess;

  /// 连接失败回调
  Function(int code)? onConnectedFailed;

  // ==================== 服务依赖 ====================

  MessageStorageService get _messageStorage =>
      Get.find<MessageStorageService>();

  // ==================== 初始化 ====================

  @override
  Future<void> onInit() async {
    super.onInit();
    developer.log('🚀 ==================== 融云IM服务初始化 ====================');

    try {
      // 1. 创建融云引擎
      await _createEngine();

      // 2. 设置监听器
      _setupListeners();

      // 3. 从本地存储恢复状态
      await _restoreFromStorage();

      developer.log('✅ 融云IM服务初始化完成');
      developer.log('   App Key: $appKey');
      developer.log('   SDK版本: 5.6.12');
    } catch (e) {
      developer.log('❌ 融云IM服务初始化失败: $e');
      rethrow;
    }
  }

  /// 创建融云引擎
  Future<void> _createEngine() async {
    try {
      developer.log('🔧 创建融云引擎...');

      // 创建引擎配置
      RCIMIWEngineOptions options = RCIMIWEngineOptions.create();

      // 创建引擎实例
      _engine = await RCIMIWEngine.create(appKey, options);

      if (_engine == null) {
        throw Exception('融云引擎创建失败：返回null');
      }

      developer.log('✅ 融云引擎创建成功');
    } catch (e) {
      developer.log('❌ 融云引擎创建失败: $e');
      rethrow;
    }
  }

  /// 设置监听器
  void _setupListeners() {
    if (_engine == null) {
      developer.log('⚠️ 引擎未创建，无法设置监听器');
      return;
    }

    developer.log('🔧 设置融云监听器...');

    // 监听连接状态变化
    _engine!.onConnectionStatusChanged = (RCIMIWConnectionStatus? status) {
      if (status == null) return;

      developer.log('🔗 融云连接状态变化: ${_getStatusName(status)}');

      connectionStatus.value = status;

      // 更新连接状态标志
      switch (status) {
        case RCIMIWConnectionStatus.connected:
          isConnected.value = true;
          isConnecting.value = false;
          developer.log('✅ 融云连接成功');
          onConnectedSuccess?.call();
          break;

        case RCIMIWConnectionStatus.connecting:
          isConnected.value = false;
          isConnecting.value = true;
          developer.log('🔄 融云连接中...');
          break;

        case RCIMIWConnectionStatus.timeout:
        case RCIMIWConnectionStatus.networkUnavailable:
          isConnected.value = false;
          isConnecting.value = false;
          developer.log('❌ 融云连接断开或超时');
          break;

        default:
          isConnected.value = false;
          isConnecting.value = false;
          developer.log('⚠️ 融云未知连接状态');
          break;
      }

      // 触发自定义回调
      onConnectionStatusChanged?.call(status);
    };

    // 🔥 监听消息接收（核心功能）
    _engine!.onMessageReceived =
        (RCIMIWMessage? message, int? left, bool? offline, bool? hasPackage) {
          if (message == null) return;

          developer.log('📥 ========== 收到新消息 ==========');
          developer.log('   发送者: ${message.senderUserId}');
          developer.log('   离线消息: $offline');
          developer.log('   剩余消息数: $left');

          // 🔥 处理接收到的消息
          _handleReceivedMessage(message);

          // 广播消息到流
          _messageStreamController.add(message);

          // 触发自定义回调
          onMessageReceived?.call(message);
        };

    developer.log('✅ 融云监听器设置完成');
  }

  /// 🔥 处理接收到的消息（核心业务逻辑）
  Future<void> _handleReceivedMessage(RCIMIWMessage message) async {
    try {
      // 🔥 打印融云消息原始信息
      developer.log('🔥 ========== 融云消息原始数据 ==========');
      developer.log('   消息ID: ${message.messageId}');
      developer.log('   发送者ID: ${message.senderUserId}');
      developer.log('   目标ID: ${message.targetId}');
      developer.log('   会话类型: ${message.conversationType}');
      developer.log('   消息类型: ${message.messageType}');
      developer.log('   发送时间: ${message.sentTime}');
      developer.log('   接收时间: ${message.receivedTime}');
      developer.log('   离线状态: ${message.offLine}');
      developer.log('   extra: ${message.extra}');
      developer.log('   localExtra: ${message.localExtra}');
      developer.log('   messageUId: ${message.messageUId}');
      developer.log('   消息对象类型: ${message.runtimeType}');
      developer.log('🔥 ========================================');

      // 1. 提取消息内容
      final content = _extractMessageContent(message);
      final senderId = message.senderUserId ?? 'unknown';

      developer.log('🔍 处理消息: $content (发送者: $senderId)');

      // 2. 识别消息类型
      final messageType = _identifyMessageType(content);
      developer.log('🏷️ 消息类型: $messageType');

      // 3. 🔥 获取发送者信息（优先从消息extra中提取，参考playtrue3架构）
      String senderName = '未知用户';
      String senderAvatar = '';
      int? friendId; // 🔥 新增：保存好友ID用于跳转

      // 🔥 特殊处理：活动审核结果消息使用"系统通知"作为发送者
      if (messageType == 'activity_review') {
        senderName = '系统通知';
        senderAvatar = ''; // 可以设置一个系统通知的默认头像
        developer.log('📢 活动审核结果消息，使用系统通知作为发送者');
      } else {
        try {
          developer.log('🔍 开始获取发送者信息...');
          developer.log('   融云发送者ID（手机号）: $senderId');
          developer.log('   消息类型: $messageType');

          // 🔥 方法1（最优）：从消息extra中提取用户信息（参考playtrue3架构）
          // 这样可以直接获取发送者的昵称和头像，无需查询列表
          if (message.extra?.isNotEmpty == true) {
            try {
              final messageExtra =
                  jsonDecode(message.extra!) as Map<String, dynamic>;
              senderName = messageExtra['userName'] as String? ?? senderName;
              senderAvatar =
                  messageExtra['userAvatarUrl'] as String? ?? senderAvatar;
              developer.log('✅ 从消息extra中获取用户信息成功');
              developer.log('   发送者姓名: $senderName');
              developer.log(
                '   头像: ${senderAvatar.isNotEmpty ? "已获取" : "无头像"}',
              );
            } catch (e) {
              developer.log('⚠️ 解析消息extra失败: $e');
            }
          }

          final userService = Get.find<UserService>();

          // 🔥 方法2（备选）：根据消息类型从不同列表查询发送者信息
          // 如果extra中没有获取到完整信息，则尝试从列表中查询
          if (messageType == 'friend_request') {
            // 🔥 好友申请消息处理
            developer.log('📋 处理好友申请消息...');

            // 🔥 重要：好友申请的发送者可能还不在好友列表中（因为还没成为好友）
            // 优先从好友申请列表查询，获取friendId用于跳转
            var friendRequests = userService.friendRequestListRx;
            developer.log('📋 当前好友申请列表数量: ${friendRequests.length}');

            var sender = friendRequests.firstWhereOrNull(
              (request) => request.senderPhone == senderId,
            );

            // 🔥 如果在当前列表中找不到，尝试刷新好友申请列表
            if (sender == null) {
              developer.log('⚠️ 在当前好友申请列表中未找到发送者，尝试刷新列表...');
              try {
                await userService.getFriendRequestList(forceRefresh: true);
                friendRequests = userService.friendRequestListRx;
                developer.log('✅ 好友申请列表已刷新，新数量: ${friendRequests.length}');

                // 重新查找
                sender = friendRequests.firstWhereOrNull(
                  (request) => request.senderPhone == senderId,
                );
              } catch (e) {
                developer.log('💥 刷新好友申请列表失败: $e');
              }
            }

            if (sender != null) {
              // 🔥 只在extra中没有获取到信息时，才使用列表中的信息覆盖
              if (senderName == '未知用户' || senderName.isEmpty) {
                senderName = sender.senderName ?? '未知用户';
              }
              if (senderAvatar.isEmpty) {
                senderAvatar = sender.senderAvatar ?? '';
              }
              friendId = sender.senderId; // 🔥 使用senderId作为跳转ID
              developer.log('✅ 在好友申请列表中找到发送者: $senderName');
              developer.log('   发送者ID: ${sender.senderId}');
              developer.log('   手机号: ${sender.senderPhone}');
              developer.log('   头像URL: $senderAvatar');
            } else {
              developer.log('⚠️ 在好友申请列表中未找到发送者');
              developer.log('   但已从消息extra中获取基本信息: $senderName');
              developer.log('   查找的手机号: $senderId');
            }
          } else {
            // 🔥 其他消息类型：从好友列表查询
            developer.log('📋 从好友列表查询发送者信息...');
            final friends = userService.friendListRx;
            developer.log('📋 当前好友列表数量: ${friends.length}');

            // 🔥 关键修复：用userPhone字段匹配融云用户ID（手机号）
            final sender = friends.firstWhereOrNull((friend) {
              final matchByPhone = friend.userPhone == senderId;
              if (matchByPhone) {
                developer.log(
                  '🎯 通过手机号匹配成功: ${friend.username} (手机: ${friend.userPhone})',
                );
              }
              return matchByPhone;
            });

            if (sender != null) {
              // 🔥 只在extra中没有获取到信息时，才使用列表中的信息覆盖
              if (senderName == '未知用户' || senderName.isEmpty) {
                senderName = sender.username ?? '未知用户';
              }
              if (senderAvatar.isEmpty) {
                senderAvatar = sender.userAvatarUrl ?? '';
              }
              friendId = sender.friendId; // 🔥 保存好友ID
              developer.log('✅ 在好友列表中找到发送者: $senderName');
              developer.log('   好友ID: ${sender.friendId}');
              developer.log('   手机号: ${sender.userPhone}');
              developer.log('   头像URL: $senderAvatar');
            } else {
              developer.log('⚠️ 在好友列表中未找到发送者');
              developer.log('   但已从消息extra中获取基本信息: $senderName');
              developer.log('   查找的手机号: $senderId');
            }
          }

          developer.log('📊 最终发送者信息:');
          developer.log('   姓名: $senderName');
          developer.log(
            '   头像: ${senderAvatar.isNotEmpty ? senderAvatar : "无"}',
          );
          developer.log('   friendId: ${friendId ?? "无"}');
        } catch (e) {
          developer.log('💥 获取发送者信息异常: $e');
        }
      }

      // 4. 创建消息实体
      final chatMessage = ChatMessageEntity(
        content: content,
        isMe: false,
        timestamp: message.sentTime ?? DateTime.now().millisecondsSinceEpoch,
        userId: senderId,
        messageId: message.messageId?.toString(),
        senderName: senderName,
        senderAvatar: senderAvatar,
        messageType: messageType,
      );

      // 5. 保存消息到本地存储
      await _messageStorage.saveMessage(chatMessage);
      developer.log('💾 消息已保存到本地存储');

      final bool isInBackground = AppLifecycleManager.instance.isInBackground;

      if (isInBackground) {
        try {
          developer.log('🔔 应用在后台，发送系统级通知');
          await BackgroundNotificationHelper.instance.showChatNotification(
            senderPhone: senderId,
            friendId: friendId,
            senderName: senderName,
            senderAvatar: senderAvatar,
            messageContent: content,
          );
        } catch (e) {
          developer.log('💥 后台系统通知异常: $e');
        }
      } else {
        // 🔥 6. 智能通知处理
        try {
          developer.log('🔔 开始智能通知处理...');
          await SmartNotificationUtil.instance.handleMessageNotification(
            senderUserId: senderId,
            friendId: friendId, // 🔥 传递好友ID用于跳转
            senderName: senderName,
            senderAvatar: senderAvatar,
            messageContent: content,
            messageId: message.messageId?.toString(),
          );
          developer.log('✅ 智能通知处理完成');
        } catch (e) {
          developer.log('💥 智能通知处理异常: $e');
        }
      }

      developer.log('✅ 消息处理完成');
    } catch (e) {
      developer.log('💥 处理接收消息异常: $e');
    }
  }

  /// 🔥 识别消息类型
  String _identifyMessageType(String content) {
    // 1. 检查是否是好友申请消息（支持多种格式）
    // 🔥 优先使用灵活匹配（包含"好友申请"关键词即可）
    if (content.contains('好友申请')) {
      developer.log('🏷️ 识别为好友申请消息（关键词匹配: 好友申请）');
      return 'friend_request';
    }

    // 兼容其他格式
    for (final flag in _friendRequestFlags) {
      if (content.contains(flag)) {
        developer.log('🏷️ 识别为好友申请消息，匹配标识: $flag');
        return 'friend_request';
      }
    }

    // 2. 检查是否是活动申请消息
    if (content.contains(_activityRequestFlag)) {
      developer.log('🏷️ 识别为活动申请消息');
      return 'activity_request';
    }

    // 🔥 3. 检查是否是活动审核结果消息（来自小程序）
    if (content.contains('申请参加的活动') &&
        (content.contains('审核已通过') || content.contains('审核已被拒绝'))) {
      developer.log('🏷️ 识别为活动审核结果消息');
      return 'activity_review';
    }

    // 4. 默认为普通聊天消息
    return 'chat';
  }

  /// 从本地存储恢复状态
  Future<void> _restoreFromStorage() async {
    try {
      final storage = StorageService.to;

      // 恢复Token
      final savedToken = storage.getString(_keyRongCloudToken);
      if (savedToken != null && savedToken.isNotEmpty) {
        currentToken.value = savedToken;
        developer.log('📦 从本地存储恢复Token');
      }

      // 恢复用户ID
      final savedUserId = storage.getString(_keyUserId);
      if (savedUserId != null && savedUserId.isNotEmpty) {
        currentUserId.value = savedUserId;
        developer.log('📦 从本地存储恢复用户ID: $savedUserId');
      }
    } catch (e) {
      developer.log('⚠️ 从本地存储恢复状态失败: $e');
    }
  }

  // ==================== 连接管理 ====================

  /// 连接融云IM服务器
  ///
  /// ⚠️ 重要提示：
  /// - SDK 自带重连机制，应用生命周期内无需多次调用
  /// - 只在登录成功或应用启动时调用一次即可
  /// - 避免重复调用，否则可能触发多个回调被清除
  Future<bool> connect({
    required String token,
    required String userId,
    int timeout = 10,
  }) async {
    try {
      developer.log('🔗 ==================== 开始连接融云IM ====================');
      developer.log('   用户ID: $userId');
      developer.log('   Token长度: ${token.length}');
      developer.log('   超时时间: $timeout秒');

      // 1. 验证参数
      if (token.isEmpty) {
        developer.log('❌ Token为空，无法连接');
        return false;
      }

      if (_engine == null) {
        developer.log('❌ 引擎未初始化，无法连接');
        return false;
      }

      // 🔥 2. 智能连接检查（防止重复连接）
      // 如果已连接且Token相同，直接返回成功
      if (isConnected.value && currentToken.value == token) {
        developer.log('✅ 已连接，无需重复连接（SDK自带重连机制）');
        return true;
      }

      // 🔥 如果正在连接中，等待连接完成（避免重复调用connect）
      if (isConnecting.value) {
        developer.log('⏳ 已有连接正在进行中，等待连接完成...');
        final result = await _waitForConnectionCallback();
        if (result) {
          developer.log('✅ 等待的连接已完成');
          return true;
        } else {
          developer.log('⚠️ 等待的连接超时或失败');
          // 继续执行新的连接尝试
        }
      }

      // 3. 设置连接状态
      isConnecting.value = true;
      isConnected.value = false;

      // 4. 保存Token和用户ID
      currentToken.value = token;
      currentUserId.value = userId;
      await _saveToStorage(token, userId);

      // 5. 创建连接回调
      final callback = RCIMIWConnectCallback(
        onConnected: (int? code, String? userId) {
          developer.log('🎉 融云连接回调: code=$code, userId=$userId');

          // 🔥 处理成功连接（code=0）
          if (code == 0) {
            isConnected.value = true;
            isConnecting.value = false;
            currentUserId.value = userId ?? '';
            developer.log('✅ 融云连接成功');

            onConnectedSuccess?.call();
          }
          // 🔥 处理连接已存在（code=34001）- 视为成功
          else if (code == 34001) {
            isConnected.value = true;
            isConnecting.value = false;
            currentUserId.value = userId ?? currentUserId.value;
            developer.log('✅ 融云连接已存在，更新状态为已连接 (code=34001)');

            onConnectedSuccess?.call();
          }
          // 🔥 其他错误码视为连接失败
          else {
            isConnected.value = false;
            isConnecting.value = false;
            developer.log('❌ 连接失败: code=$code');
            onConnectedFailed?.call(code ?? -1);
          }
        },
        onDatabaseOpened: (int? code) {
          developer.log('📦 融云数据库已打开: code=$code');
        },
      );

      // 6. 发起连接
      developer.log('🚀 发起融云连接请求...');
      final ret = await _engine!.connect(token, timeout, callback: callback);

      if (ret == 0) {
        developer.log('✅ 连接请求发送成功，等待回调...');
        return await _waitForConnection(timeout);
      } else {
        developer.log('❌ 连接请求失败: code=$ret');
        isConnecting.value = false;
        return false;
      }
    } catch (e) {
      developer.log('💥 连接融云IM异常: $e');
      isConnecting.value = false;
      isConnected.value = false;
      return false;
    }
  }

  /// 断开融云IM连接
  Future<bool> disconnect({bool receivePush = false}) async {
    try {
      developer.log('🔌 断开融云IM连接...');

      if (_engine == null) {
        developer.log('⚠️ 引擎未初始化');
        return false;
      }

      final ret = await _engine!.disconnect(receivePush);

      if (ret == 0) {
        isConnected.value = false;
        isConnecting.value = false;
        developer.log('✅ 融云IM连接已断开');
        return true;
      } else {
        developer.log('❌ 断开连接失败: code=$ret');
        return false;
      }
    } catch (e) {
      developer.log('💥 断开连接异常: $e');
      isConnected.value = false;
      isConnecting.value = false;
      return false;
    }
  }

  /// 等待连接完成
  Future<bool> _waitForConnection(int timeout) async {
    final maxWaitTime = timeout * 2;

    for (int i = 0; i < maxWaitTime; i++) {
      if (isConnected.value) {
        developer.log('✅ 连接成功');
        return true;
      }

      if (!isConnecting.value) {
        developer.log('⚠️ 连接已中断');
        return false;
      }

      await Future.delayed(const Duration(milliseconds: 500));
    }

    developer.log('⏰ 等待连接超时');
    isConnecting.value = false;
    return false;
  }

  /// 🔥 新增：等待连接状态回调（用于发送消息时的智能连接检查）
  Future<bool> _waitForConnectionCallback() async {
    final maxWaitTime = 5; // 最多等待5秒
    for (int i = 0; i < maxWaitTime * 4; i++) {
      if (isConnected.value) {
        return true;
      }
      await Future.delayed(const Duration(milliseconds: 250));
    }
    return false;
  }

  // ==================== 消息发送 ====================

  /// 发送文本消息（修复版本 - 智能连接检查和重试）
  Future<bool> sendTextMessage({
    required String targetId,
    required String content,
    RCIMIWConversationType conversationType = RCIMIWConversationType.private,
    bool showLoading = false,
  }) async {
    try {
      developer.log('📤 发送文本消息:');
      developer.log('   目标用户: $targetId');
      developer.log('   消息内容: $content');

      // 1. 验证参数
      if (_engine == null) {
        developer.log('❌ 引擎未初始化');
        LoadingUtil.error('IM服务未初始化');
        return false;
      }

      // 🔥 智能连接检查 - 优先等待连接，避免重复调用 connect()
      if (!isConnected.value) {
        developer.log('⚠️ 融云未连接，检查连接状态...');

        // 🔥 如果正在连接中，等待连接完成（不调用新的 connect）
        if (isConnecting.value) {
          developer.log('⏳ 正在连接中，等待连接完成...');
          final waitResult = await _waitForConnectionCallback();
          if (!waitResult) {
            developer.log('❌ 等待连接超时');
            LoadingUtil.error('连接中，请稍后重试');
            return false;
          }
          developer.log('✅ 连接已完成，继续发送消息');
        } else {
          // 🔥 未连接且未在连接中
          // 提示用户：SDK 有自动重连机制，如果仍未连接可能需要检查网络或重新登录
          developer.log('❌ 融云未连接且未在连接中');
          developer.log('💡 提示：SDK 自带重连机制，如果长时间未连接请检查：');
          developer.log('   1. 网络连接是否正常');
          developer.log('   2. Token 是否有效');
          developer.log('   3. 是否需要重新登录');

          // 🔥 仅在必要时尝试重连（Token和用户ID都存在时）
          if (currentToken.value.isNotEmpty && currentUserId.value.isNotEmpty) {
            developer.log('🔄 尝试重新连接融云（仅此一次）...');
            final connected = await connect(
              token: currentToken.value,
              userId: currentUserId.value,
            );
            if (!connected) {
              developer.log('❌ 重连失败');
              LoadingUtil.error('IM服务未连接，请稍后重试');
              return false;
            }
          } else {
            developer.log('❌ Token或用户ID为空，无法连接');
            LoadingUtil.error('请重新登录');
            return false;
          }
        }

        // 🔥 最终确认连接状态
        if (!isConnected.value) {
          developer.log('❌ 连接检查失败，无法发送消息');
          LoadingUtil.error('IM服务连接失败');
          return false;
        }

        developer.log('✅ 融云连接已就绪');
      }

      if (targetId.isEmpty || content.isEmpty) {
        developer.log('❌ 目标用户ID或消息内容为空');
        LoadingUtil.info('消息内容不能为空');
        return false;
      }

      // 2. 显示Loading（可选）
      if (showLoading) {
        LoadingUtil.show('发送中...');
      }

      // 3. 创建文本消息
      final textMessage = await _engine!.createTextMessage(
        conversationType,
        targetId,
        '',
        content,
      );

      if (textMessage == null) {
        developer.log('❌ 创建文本消息失败');
        if (showLoading) LoadingUtil.dismiss();
        LoadingUtil.error('消息创建失败');
        return false;
      }

      // 🔥 3.5. 添加用户信息到extra（参考playtrue3的实现）
      await _setMessageExtra(textMessage);

      // 4. 发送消息
      final ret = await _engine!.sendMessage(textMessage);

      if (showLoading) LoadingUtil.dismiss();

      if (ret == 0) {
        developer.log('✅ 消息发送成功');

        // 5. 🔥 保存发送的消息到本地
        final chatMessage = ChatMessageEntity(
          content: content,
          isMe: true,
          timestamp: DateTime.now().millisecondsSinceEpoch,
          userId: targetId,
          messageId: DateTime.now().millisecondsSinceEpoch.toString(),
          messageType: 'chat',
        );
        await _messageStorage.saveMessage(chatMessage);

        return true;
      } else {
        developer.log('❌ 消息发送失败: code=$ret');
        LoadingUtil.error('消息发送失败');
        return false;
      }
    } catch (e) {
      developer.log('💥 发送消息异常: $e');
      LoadingUtil.error('消息发送失败');
      return false;
    }
  }

  // ==================== 消息处理 ====================

  /// 🔥 设置消息的extra数据（参考playtrue3实现）
  ///
  /// 在发送消息前调用，将当前用户的信息添加到消息的extra字段中
  /// 这样接收方可以直接从消息中获取发送者的昵称和头像
  Future<void> _setMessageExtra(RCIMIWTextMessage textMessage) async {
    try {
      final userService = Get.find<UserService>();
      final userInfo = userService.userInfo;

      // 🔥 构建extra数据，包含用户名和头像URL
      final userName = userInfo?.username ?? '未知用户';
      final userAvatar = userInfo?.userAvatarUrl ?? '';

      final extraData = <String, dynamic>{
        'userName': userName.isNotEmpty ? userName : '未知用户',
        'userAvatarUrl': userAvatar,
      };

      // 转换为JSON字符串
      final extraJson = jsonEncode(extraData);

      // 设置extra到消息中
      textMessage.extra = extraJson;

      developer.log('📝 设置消息extra: $extraJson');
    } catch (e) {
      developer.log('💥 设置消息extra异常: $e');
    }
  }

  // ==================== 消息查询 ====================

  /// 🔥 获取某个用户的聊天消息
  Future<List<ChatMessageEntity>> getUserMessages(String userId) async {
    try {
      return await _messageStorage.getMessages(userId);
    } catch (e) {
      developer.log('💥 获取用户消息异常: $e');
      return [];
    }
  }

  /// 🔥 获取某个用户的未读数
  Future<UnreadMessageCount> getUserUnreadCount(String userId) async {
    try {
      return await _messageStorage.getUserUnreadCount(userId);
    } catch (e) {
      developer.log('💥 获取用户未读数异常: $e');
      return UnreadMessageCount();
    }
  }

  /// 🔥 清除某个用户的未读数
  Future<void> clearUserUnreadCount(String userId) async {
    try {
      await _messageStorage.clearUserUnreadCount(userId);
      developer.log('🗑️ 已清除用户 $userId 的未读数');
    } catch (e) {
      developer.log('💥 清除用户未读数异常: $e');
    }
  }

  /// 🔥 获取全局未读数统计
  Future<UnreadMessageCount> getTotalUnreadCount() async {
    try {
      return await _messageStorage.getTotalUnreadCount();
    } catch (e) {
      developer.log('💥 获取全局未读数异常: $e');
      return UnreadMessageCount();
    }
  }

  /// 🔥 清除所有未读数
  Future<void> clearAllUnreadCount() async {
    try {
      await _messageStorage.clearAllUnreadCount();
      developer.log('🗑️ 已清除所有未读数');
    } catch (e) {
      developer.log('💥 清除所有未读数异常: $e');
    }
  }

  /// 🔥 获取所有有消息的用户列表
  Future<List<String>> getAllUserIdsWithMessages() async {
    try {
      return await _messageStorage.getAllUserIds();
    } catch (e) {
      developer.log('💥 获取用户列表异常: $e');
      return [];
    }
  }

  // ==================== 工具方法 ====================

  /// 提取消息内容
  String _extractMessageContent(RCIMIWMessage message) {
    try {
      // 检查消息类型是否为文本消息
      if (message is RCIMIWTextMessage) {
        final textContent = message.text;
        if (textContent != null && textContent.isNotEmpty) {
          return textContent;
        }
      }

      // 如果不是文本消息，返回消息类型说明
      developer.log('⚠️ 非文本消息类型: ${message.runtimeType}');
      return '[非文本消息]';
    } catch (e) {
      developer.log('💥 提取消息内容异常: $e');
      return '[消息解析失败]';
    }
  }

  /// 获取连接状态名称
  String _getStatusName(RCIMIWConnectionStatus status) {
    switch (status) {
      case RCIMIWConnectionStatus.connected:
        return '已连接';
      case RCIMIWConnectionStatus.connecting:
        return '连接中';
      case RCIMIWConnectionStatus.timeout:
        return '连接超时';
      case RCIMIWConnectionStatus.networkUnavailable:
        return '网络不可用';
      default:
        return '未知状态';
    }
  }

  // ==================== 本地存储 ====================

  /// 保存Token和用户ID到本地存储
  Future<void> _saveToStorage(String token, String userId) async {
    try {
      final storage = StorageService.to;
      await storage.setString(_keyRongCloudToken, token);
      await storage.setString(_keyUserId, userId);
      developer.log('💾 Token和用户ID已保存到本地');
    } catch (e) {
      developer.log('⚠️ 保存到本地存储失败: $e');
    }
  }

  /// 清除本地存储的Token和用户ID
  Future<void> clearStorage() async {
    try {
      final storage = StorageService.to;
      await storage.remove(_keyRongCloudToken);
      await storage.remove(_keyUserId);
      currentToken.value = '';
      currentUserId.value = '';
      developer.log('🧹 已清除本地存储的Token和用户ID');
    } catch (e) {
      developer.log('⚠️ 清除本地存储失败: $e');
    }
  }

  // ==================== 清理 ====================

  @override
  void onClose() {
    developer.log('🧹 融云IM服务正在清理...');

    // 关闭消息流
    _messageStreamController.close();

    // 断开连接
    disconnect(receivePush: false);

    // 销毁引擎
    if (_engine != null) {
      _engine!.destroy();
      _engine = null;
      developer.log('✅ 融云引擎已销毁');
    }

    super.onClose();
  }
}
